
import time
import numpy as np
import pandas as pd
import seaborn as sns
from matplotlib import pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score, KFold
from sklearn.metrics import accuracy_score, confusion_matrix, make_scorer, roc_auc_score, precision_score, recall_score, f1_score
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

# Concept drift
from river.drift import ADWIN, KSWIN, PageHinkley
from river import metrics
from river import stream
from river import forest
from river import ensemble

%matplotlib inline


# Cargar datos desde un archivo CSV
df = pd.read_csv('HotelReservations.csv')


# Ver información básica del DataFrame
df.info()

# Ver las primeras filas de los datos
df.head()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 36275 entries, 0 to 36274
Data columns (total 19 columns):
 #   Column                                Non-Null Count  Dtype  
---  ------                                --------------  -----  
 0   Booking_ID                            36275 non-null  object 
 1   no_of_adults                          36275 non-null  int64  
 2   no_of_children                        36275 non-null  int64  
 3   no_of_weekend_nights                  36275 non-null  int64  
 4   no_of_week_nights                     36275 non-null  int64  
 5   type_of_meal_plan                     36275 non-null  object 
 6   required_car_parking_space            36275 non-null  int64  
 7   room_type_reserved                    36275 non-null  object 
 8   lead_time                             36275 non-null  int64  
 9   arrival_year                          36275 non-null  int64  
 10  arrival_month                         36275 non-null  int64  
 11  arrival_date                          36275 non-null  int64  
 12  market_segment_type                   36275 non-null  object 
 13  repeated_guest                        36275 non-null  int64  
 14  no_of_previous_cancellations          36275 non-null  int64  
 15  no_of_previous_bookings_not_canceled  36275 non-null  int64  
 16  avg_price_per_room                    36275 non-null  float64
 17  no_of_special_requests                36275 non-null  int64  
 18  booking_status                        36275 non-null  object 
dtypes: float64(1), int64(13), object(5)
memory usage: 5.3+ MB


# Obtener estadísticas descriptivas de las variables númericas
print('Descripción estadística de las variables numéricas')
df.describe().transpose()

Descripción estadística de las variables numéricas


# Obtener estadísticas descriptivas de las variables númericas
print('Descripción estadística de las variables categóricas')
df[['Booking_ID', 'type_of_meal_plan', 'room_type_reserved', 'market_segment_type', 'booking_status']].astype('object').describe().transpose()

Descripción estadística de las variables categóricas


# Verificar si hay valores faltantes en el DataFrame
print(df.isnull().sum())

# Eliminar filas o columnas con valores faltantes
df = df.dropna()

Booking_ID                              0
no_of_adults                            0
no_of_children                          0
no_of_weekend_nights                    0
no_of_week_nights                       0
type_of_meal_plan                       0
required_car_parking_space              0
room_type_reserved                      0
lead_time                               0
arrival_year                            0
arrival_month                           0
arrival_date                            0
market_segment_type                     0
repeated_guest                          0
no_of_previous_cancellations            0
no_of_previous_bookings_not_canceled    0
avg_price_per_room                      0
no_of_special_requests                  0
booking_status                          0
dtype: int64


# Contar los valores únicos en una columna
booking_status_vc = df['booking_status'].value_counts()
print(booking_status_vc)

# Crear un histograma de una columna
booking_status_vc.plot.bar()

plt.title('Booking Status')
plt.xlabel('Estado de reservas')
plt.ylabel('Cantidad de clientes')

# Mostrar el gráfico
plt.show()

booking_status
Not_Canceled    24390
Canceled        11885
Name: count, dtype: int64


# Representación de las variables categóricas
fig, ax = plt.subplots(1, 3, figsize = (20, 4))

ax[0].bar(df['type_of_meal_plan'].value_counts().index, df['type_of_meal_plan'].value_counts())
ax[1].bar(df['room_type_reserved'].value_counts().index, df['room_type_reserved'].value_counts())
ax[2].bar(df['market_segment_type'].value_counts().index, df['market_segment_type'].value_counts())

ax[0].set_title('type_of_meal_plan')
ax[1].set_title('room_type_reserved')
ax[2].set_title('market_segment_type')

plt.show()


# Representación de las variables numéricas
fig1, ax1 = plt.subplots(1, 5, figsize = (20, 3))
fig2, ax2 = plt.subplots(1, 5, figsize = (20, 3))
fig3, ax3 = plt.subplots(1, 4, figsize = (16, 3))

ax1[0].bar(df['no_of_adults'].value_counts().index, df['no_of_adults'].value_counts())
ax1[1].bar(df['no_of_children'].value_counts().index, df['no_of_children'].value_counts())
ax1[2].bar(df['no_of_weekend_nights'].value_counts().index, df['no_of_weekend_nights'].value_counts())
ax1[3].bar(df['no_of_week_nights'].value_counts().index, df['no_of_week_nights'].value_counts())
ax1[4].bar(df['required_car_parking_space'].value_counts().index, df['required_car_parking_space'].value_counts())
ax2[0].hist(df['lead_time'])
ax2[1].bar(df['arrival_year'].value_counts().index, df['arrival_year'].value_counts())
ax2[2].bar(df['arrival_month'].value_counts().index, df['arrival_month'].value_counts())
ax2[3].hist(df['arrival_date'])
ax2[4].bar(df['repeated_guest'].value_counts().index, df['repeated_guest'].value_counts())
ax3[0].bar(df['no_of_previous_cancellations'].value_counts().index, df['no_of_previous_cancellations'].value_counts())
ax3[1].hist(df['no_of_previous_bookings_not_canceled'])
ax3[2].bar(df['avg_price_per_room'].value_counts().index, df['avg_price_per_room'].value_counts())
ax3[3].bar(df['no_of_special_requests'].value_counts().index, df['no_of_special_requests'].value_counts())


ax1[0].set_title('no_of_adults')
ax1[1].set_title('no_of_children')
ax1[2].set_title('no_of_weekend_nights')
ax1[3].set_title('no_of_week_nights')
ax1[4].set_title('required_car_parking_space')
ax2[0].set_title('lead_time')
ax2[1].set_title('arrival_year')
ax2[2].set_title('arrival_month')
ax2[3].set_title('arrival_date')
ax2[4].set_title('repeated_guest')
ax3[0].set_title('no_of_previous_cancellations')
ax3[1].set_title('no_of_previous_bookings_not_canceled')
ax3[2].set_title('avg_price_per_room')
ax3[3].set_title('no_of_special_requests')

plt.show()


# Representación de las variables en relación a 'booking_status'
plt.figure(figsize = (20, 25))
plt.suptitle("Análisis de la variable 'booking_status'",fontweight="bold", fontsize=20)

plt.subplot(5,2,1)
sns.countplot(x = 'booking_status', hue = 'no_of_adults', palette = 'Set2', data = df)

plt.subplot(5,2,2)
sns.countplot(x = 'booking_status', hue = 'no_of_children', palette = 'Set2', data = df)

plt.subplot(5,2,3)
sns.countplot(x = 'booking_status', hue = 'no_of_weekend_nights', palette = 'Set2', data = df)

plt.subplot(5,2,4)
sns.countplot(x = 'booking_status', hue = 'required_car_parking_space', palette = 'Set2', data = df)

plt.subplot(5,2,5)
sns.countplot(x = 'booking_status', hue = 'market_segment_type', palette = 'Set2', data = df)

plt.subplot(5,2,6)
sns.countplot(x = 'booking_status', hue = 'type_of_meal_plan', palette = 'Set2', data = df)

plt.subplot(5,2,7)
sns.countplot(x = 'booking_status', hue = 'room_type_reserved', palette = 'Set2', data = df)

plt.subplot(5,2,8)
sns.countplot(x = 'booking_status', hue = 'repeated_guest', palette = 'Set2', data = df)

plt.subplot(5,2,9)
sns.countplot(x = 'booking_status', hue = 'no_of_special_requests', palette = 'Set2', data = df)

plt.show()


# Representación de las relaciones entre variables 
fig, ax = plt.subplots(2,3, figsize = (20, 20))

plot1 = ax[0][0].scatter(df['lead_time'].index, df['lead_time'], c=df['booking_status'].map({'Canceled': 'red', 'Not_Canceled':'blue'}))
ax[0][0].set_title('Días antes de llegada al hotel')
ax[0][0].set_ylabel('Cantidad de días')

plot2 = ax[0][1].scatter(df['no_of_adults'], df['no_of_week_nights'], c=df['booking_status'].map({'Canceled': 'red', 'Not_Canceled':'blue'}))
ax[0][1].set_title('Número de adultos por noche')
ax[0][1].set_xlabel('Cantidad de adultos')
ax[0][1].set_ylabel('Noches')

plot3 = ax[0][2].scatter(df['arrival_month'], df['lead_time'], c=df['booking_status'].map({'Canceled': 'red', 'Not_Canceled':'blue'}))
ax[0][2].set_title('Días antes de llegada al hotel por meses')
ax[0][2].set_xlabel('Meses')
ax[0][2].set_ylabel('Cantidad de días')

plot4 = ax[1][0].scatter(df['arrival_month'], df['avg_price_per_room'], c=df['booking_status'].map({'Canceled': 'red', 'Not_Canceled':'blue'}))
ax[1][0].set_title('Precio medio por mes')
ax[1][0].set_xlabel('Meses')
ax[1][0].set_ylabel('Euros')

plot5 = ax[1][1].scatter(df['room_type_reserved'], df['avg_price_per_room'], c=df['booking_status'].map({'Canceled': 'red', 'Not_Canceled':'blue'}))
ax[1][1].set_title('Precio medio por tipo de habitación')
ax[1][1].set_ylabel('Euros')

plot6 = ax[1][2].scatter(df['no_of_special_requests'], df['avg_price_per_room'], c=df['booking_status'].map({'Canceled': 'red', 'Not_Canceled':'blue'}))
ax[1][2].set_title('Precio de habitaciones con peticiones especiales')
ax[1][2].set_xlabel('Cantidad de peticiones especiales')
ax[1][2].set_ylabel('Euros')


leg = plt.figlegend((plot1, plot2, plot3, plot4, plot5), ['Canceled', 'Not_Canceled'], loc='upper center', ncol=1, title='booking_status')
leg.legend_handles[0].set_color('red')
leg.legend_handles[1].set_color('blue')
plt.show()


# Creación de la variable 'no_of_guests' --> Cantidad de huéspedes en total
df['no_of_guests'] = df['no_of_adults'] + df['no_of_children']

# Creación de la variable 'no_of_nights' --> Cantidad de noches en total
df['no_of_nights'] = df['no_of_weekend_nights'] + df['no_of_week_nights']

# Creación de la fecha de llegada con todos los datos
def create_date_string(row):
    return f"{row['arrival_year']:04}{row['arrival_month']:02}{row['arrival_date']:02}"

dates = df[['arrival_year', 'arrival_month', 'arrival_date']]
df['date'] = dates.apply(create_date_string, axis=1)
df['date'] = df['date'].astype(int)


# Ajustar y transformar la lista de valores categóricos
df['type_of_meal_plan'] = df['type_of_meal_plan'].map({"Meal Plan 1": 1, 'Not Selected': 0, 'Meal Plan 2': 2 ,'Meal Plan 3': 3})
df['room_type_reserved'] = df["room_type_reserved"].map({'Room_Type 1': 1, 'Room_Type 2': 2, 'Room_Type 3': 3,'Room_Type 4': 4,'Room_Type 5': 5,'Room_Type 6': 6,'Room_Type 7': 7})
df['market_segment_type'] = df['market_segment_type'].map({"Offline": 0, 'Online': 1, 'Corporate': 2 ,'Aviation': 3,'Complementary': 4})
df['booking_status'] = df['booking_status'].map({'Canceled': 0, 'Not_Canceled': 1})

df['type_of_meal_plan'] = df['type_of_meal_plan'].astype(int)
df['room_type_reserved']= df['room_type_reserved'].astype(int)
df['market_segment_type']= df['market_segment_type'].astype(int)
df['booking_status']= df['booking_status'].astype(int)

# Extraer 'booking_status'
col = df.pop('booking_status')

# Añadir la 'booking_status' al final del DataFrame
df.insert(len(df.columns), 'booking_status', col)

hotels = df.drop(['Booking_ID', 'no_of_adults', 'no_of_children', 'no_of_weekend_nights', 'no_of_week_nights',\
                  'arrival_year', 'arrival_month', 'arrival_date'], axis=1)
hotels.head()


plt.figure(figsize = (14,7))

sns.heatmap(hotels.corr().round(2), annot = True, cmap = 'coolwarm')

<Axes: >


# REDUCCIÓN DE DIMENSIONALIDAD / Variables con valor de correlación entre -0.1 y 0.1 se van a borrar 
hotels_cleaned = hotels.drop(['type_of_meal_plan', 'room_type_reserved', 'no_of_previous_cancellations', 'no_of_previous_bookings_not_canceled'], axis=1)

# Ordenar las reservas por fecha
hotels_cleaned.sort_values('date', inplace=True)
hotels_cleaned.head()


features = hotels_cleaned.loc[:, hotels_cleaned.columns != 'booking_status']
target = hotels_cleaned['booking_status']
X_train, X_test, y_train, y_test = train_test_split(features, target, test_size=0.2, random_state=24)


# Hacer una instancia del modelo DecisionTreeClassifier
train_tree = DecisionTreeClassifier(max_depth = 5, random_state = 24).fit(X_train, y_train)

# Representación del árbol de decisión
plt.figure(figsize=(10, 8))
plot_tree(train_tree, feature_names=list(features.columns), fontsize=12)

# Calculando precisión y matriz de confusión del modelo de train
y_train_pred = train_tree.predict(X_train)
tree_train_accuracy = accuracy_score(y_train, y_train_pred)
print("Precisión de modelo train: {}".format(tree_train_accuracy))
print("Matriz de confusion de train:\n{}".format(confusion_matrix(y_train, y_train_pred)))

# Calculando precisión y matriz de confusión del modelo de test
y_test_pred = train_tree.predict(X_test)
tree_test_accuracy = accuracy_score(y_test, y_test_pred)
print("Precisión de modelo test: {}".format(tree_test_accuracy))
print("Matriz de confusion:\n{}".format(confusion_matrix(y_test, y_test_pred)))

Precisión de modelo train: 0.8330806340454858
Matriz de confusion de train:
[[ 6787  2748]
 [ 2096 17389]]
Precisión de modelo test: 0.8237077877325982
Matriz de confusion:
[[1634  716]
 [ 563 4342]]


# Grid de hiperparámetros evaluados
param_grid = {'max_depth': [4, 5, 7, 8, 10, 11]}

# Búsqueda por grid search con validación cruzada
grid = GridSearchCV(
        estimator  = RandomForestClassifier(random_state=24),
        param_grid = param_grid
       )

grid.fit(X_train, y_train)

print("El mejor conjunto de parámetros encontrado en el conjunto de desarrollo: {}".format(grid.best_params_))

# Hacer una instancia del modelo RandomForestClassifier
train_rfc = RandomForestClassifier(random_state = 24).fit(X_train, y_train)

# Calculando precisión y matriz de confusión del modelo de test
y_test_pred = train_rfc.predict(X_test)
rfc_test_accuracy = accuracy_score(y_test, y_test_pred)
print("Precisión de modelo test: {}".format(rfc_test_accuracy))
print("Matriz de confusion:\n{}".format(confusion_matrix(y_test, y_test_pred)))

El mejor conjunto de parámetros encontrado en el conjunto de desarrollo: {'max_depth': 11}
Precisión de modelo test: 0.8949689869055824
Matriz de confusion:
[[1888  462]
 [ 300 4605]]


# Definir las etapas del modelo
model = Pipeline([
    ('scale', StandardScaler()),
    ('lin_reg', LogisticRegression(solver='lbfgs'))
])

model.fit(X_train, y_train)

# Calculando precisión y matriz de confusión del modelo de test
y_test_pred = model.predict(X_test)
lr_test_accuracy = accuracy_score(y_test, y_test_pred)
print("Precisión de modelo test: {}".format(lr_test_accuracy))
print("Matriz de confusion:\n{}".format(confusion_matrix(y_test, y_test_pred)))

Precisión de modelo test: 0.7937973811164714
Matriz de confusion:
[[1368  982]
 [ 514 4391]]


# Definir un procedimiento de validación cruzada determinista
cv = KFold(n_splits=5, shuffle=True, random_state=24)

# Calcular los valores MSE
scorer = make_scorer(roc_auc_score)
scores = cross_val_score(model, features, target, scoring=scorer, cv=cv)
scores_train_tree = cross_val_score(train_tree, features, target, scoring=scorer, cv=cv)
scores_train_rfc = cross_val_score(train_rfc, features, target, scoring=scorer, cv=cv)

# Mostrar la puntuación media y su desviación estándar
print(f'ROC AUC: {scores.mean():.3f} (± {scores.std():.3f})')
print(f'ROC AUC train_tree: {scores_train_tree.mean():.3f} (± {scores_train_tree.std():.3f})')
print(f'ROC AUC train_rfc: {scores_train_rfc.mean():.3f} (± {scores_train_rfc.std():.3f})')

ROC AUC: 0.736 (± 0.007)
ROC AUC train_tree: 0.791 (± 0.003)
ROC AUC train_rfc: 0.875 (± 0.003)


# Se obtiene la importancia de las diferentes características del modelo
feature_importance = pd.DataFrame({'feature': list(features.columns), 'importance': list(train_rfc.feature_importances_)})
feature_importance.sort_values('importance', ascending=False)


# Creación de los casos
caso_1 = pd.DataFrame([[0, 60, 0, 0, 85, 1, 2, 4, 20180821]], columns=list(features.columns))
caso_2 = pd.DataFrame([[0, 28, 1, 1, 42.5, 2, 1, 8, 20180412]], columns=list(features.columns))
caso_3 = pd.DataFrame([[1, 220, 2, 0, 101, 0, 2, 3, 20170603]], columns=list(features.columns))
caso_4 = pd.DataFrame([[1, 153, 4, 1, 137.6, 0, 3, 12, 20170928]], columns=list(features.columns))

# Predicción de los casos con el modelo seleccionado
resultado_1 = train_rfc.predict(caso_1)
resultado_2 = train_rfc.predict(caso_2)
resultado_3 = train_rfc.predict(caso_3)
resultado_4 = train_rfc.predict(caso_4)

list_resultado = [resultado_1, resultado_2, resultado_3, resultado_4]

# Visualización de los resultados de las predicciones para cada caso
for n_caso in range(0, len(list_resultado)):
    if(list_resultado[n_caso]):
        print("En el caso {} no se ha cancelado la reserva".format(n_caso+1))
    else:
        print("En el caso {} se ha cancelado la reserva".format(n_caso+1))

En el caso 1 no se ha cancelado la reserva
En el caso 2 no se ha cancelado la reserva
En el caso 3 se ha cancelado la reserva
En el caso 4 se ha cancelado la reserva


# Concept drift: ADWIN
def detect_drift_ADWIN(df, t):
    first, first_drift = True, tuple()
    list_drift = {}
    adwin = ADWIN()
    for i, val in enumerate(df):
        _ = adwin.update(val)
        if adwin.drift_detected:
            list_drift[i] = val
            if t < i and first:
                first_drift = (i, val)
                first = False

    return list_drift, first_drift


# Concept drift: PageHinkley
def detect_drift_PH(df, t):
    first, first_drift = True, tuple()
    list_drift = {}
    ph = PageHinkley()
    for i, val in enumerate(df):
        _ = ph.update(val)
        if ph.drift_detected:
            list_drift[i] = val
            if t < i and first:
                first_drift = (i, val)
                first = False

    return list_drift, first_drift


# Concept drift: KSWIN
def detect_drift_KSWIN(df, t):
    first, first_drift = True, tuple()
    list_drift = {}
    kswin = KSWIN()
    for i, val in enumerate(df):
        _ = kswin.update(val)
        if kswin.drift_detected:
            list_drift[i] = val
            if t < i and first:
                first_drift = (i, val)
                first = False

    return list_drift, first_drift


# Visualización de los datos
def display_drift(list_drift, title):
    plt.scatter(list_drift.keys(), list_drift.values())
    plt.title(title)
    plt.show()


hotels_time_drift = hotels_cleaned.copy()

# Establecer la columna 'date' como índice
hotels_time_drift.set_index('date', inplace=True)

# Definir el número de filas del conjunto de datos
n_rows = len(hotels_time_drift)

# Definir el número de puntos de drift
n_drift_points = 3

# Definir la longitud de cada período de drift
drift_period = n_rows // (n_drift_points + 1)

# Inicializar la magnitud y dirección de la drift
drift_magnitude = 0.5
drift_direction = 1

# Recorrer las filas del conjunto de datos e introducir drift en los intervalos especificados
for i in range(int(n_rows/2), n_rows):
    # Determinar si se ha alcanzado un punto de drift
    if i % drift_period == 0:
        # Invertir la dirección del drift
        drift_direction *= -1
        # Actualizar la magnitud del drift
        drift_magnitude = np.random.uniform(0, 1)
    
    # Introducir la drift añadiendo un valor aleatorio a 'no_of_special_requests'
    hotels_time_drift.loc[hotels_time_drift.index[i], 'no_of_special_requests'] += drift_direction * drift_magnitude
    
    # Pausa breve para simular un entorno de flujo de datos en tiempo real
    time.sleep(0.005)


# Definir las variables iniciales
time_features = hotels_time_drift.loc[:, hotels_time_drift.columns != 'booking_status']
time_target = hotels_time_drift['booking_status']

# Entrenar el modelo con el nuevo conjunto de 'features'
X_train, X_test, y_train, y_test = train_test_split(time_features, time_target, test_size=0.2, random_state=24)
rfc_time_drift = RandomForestClassifier(random_state = 24).fit(X_train, y_train)

# Evaluar el nuevo modelo
time_y_test_pred = rfc_time_drift.predict(X_test)
time_accuracy = accuracy_score(y_test, time_y_test_pred)

print("Precisión inicial de modelo test: {}".format(rfc_test_accuracy))
print("Precisión del modelo drift por intercambio: {}".format(time_accuracy))

Precisión inicial de modelo test: 0.8949689869055824
Precisión del modelo drift por intercambio: 0.8634045485871813


list_drift, first_drift = detect_drift_ADWIN(hotels_time_drift['no_of_special_requests'], int(n_rows/2))
print("Cambio detectado en el índice {}, valor de entrada: {}".format(first_drift[0], first_drift[1]))

Cambio detectado en el índice 18207, valor de entrada: 35.0


# Visualización del concept drift con el método 'Time distribution-based drift'
display_drift(list_drift, 'ADWIN: no_of_special_requests')


list_drift, first_drift = detect_drift_PH(hotels_time_drift['no_of_special_requests'], int(n_rows/2))
print("Cambio detectado en el índice {}, valor de entrada: {}".format(first_drift[0], first_drift[1]))

Cambio detectado en el índice 18195, valor de entrada: 35.0


# Visualización del concept drift con el método 'Intercambio de features importantes'
display_drift(list_drift, 'PageHinkley: no_of_special_requests')


list_drift, first_drift = detect_drift_KSWIN(hotels_time_drift['no_of_special_requests'], int(n_rows/2))
print("Cambio detectado en el índice {}, valor de entrada: {}".format(first_drift[0], first_drift[1]))

Cambio detectado en el índice 18204, valor de entrada: 37.0


# Visualización del concept drift con el método 'Time distribution-based drift'
display_drift(list_drift, 'KSWIN: no_of_special_requests')


# FEATURE DRIFT - Eliminación de 'features' importantes para el modelo a partir de un instante t (date)
hotels_exchange_drift = hotels_cleaned.copy()

# Definir las variables iniciales
initial_features = list(features.columns)

# Definir el instante t
t = hotels_exchange_drift.index[int(n_rows/2)]

# Introducir drift de 'features'
for i in range(10):
    np.random.seed(0)
    # Elegir al azar una 'feature' para eliminar
    feature_to_remove = np.random.choice(initial_features)
    new_features = [f for f in initial_features if f != feature_to_remove]
    
    # Entrenar el modelo con el nuevo conjunto de 'features'
    X_train, X_test, y_train, y_test = train_test_split(hotels_exchange_drift[new_features], target, test_size=0.2, random_state=24)
    drift_rfc = RandomForestClassifier(random_state = 24).fit(X_train, y_train)
    
    # Evaluar la nueva precisión del modelo
    drift_y_test_pred = drift_rfc.predict(X_test)
    new_accuracy = accuracy_score(y_test, drift_y_test_pred)
    
    # Comprobar concept drift
    if new_accuracy < rfc_test_accuracy * 0.9:
        print("Concept drift detectado en la iteración {}".format(i))
        print("Precisión inicial de modelo test: {}".format(rfc_test_accuracy))
        print("Precisión del modelo drift por eliminación: {}".format(new_accuracy))
        break
    else:
        initial_accuracy = new_accuracy
        initial_features = new_features

Concept drift detectado en la iteración 3
Precisión inicial de modelo test: 0.8949689869055824
Precisión del modelo drift por eliminación: 0.8031702274293591


print("Estos son las variables que quedan después de la eliminación: {}".format(new_features))

Estos son las variables que quedan después de la eliminación: ['required_car_parking_space', 'lead_time', 'market_segment_type', 'repeated_guest', 'date']


# FEATURE DRIFT - Intercambiar 2 features importantes para el modelo a partir de un instante t
# Definir las dos 'features' importantes para intercambiar
feature1 = 'lead_time'
feature2 = 'no_of_special_requests'

# Intercambiar los dos features a partir del instante t
temp1, temp2 = hotels_exchange_drift.loc[t:, feature1].copy(), hotels_exchange_drift.loc[t:, feature2].copy()
hotels_exchange_drift.loc[t:, feature1], hotels_exchange_drift.loc[t:, feature2] = temp2, temp1


# Definir las variables iniciales
exchange_features = hotels_exchange_drift.loc[:, hotels_exchange_drift.columns != 'booking_status']
exchange_target = hotels_exchange_drift['booking_status']

# Entrenar el modelo con el nuevo conjunto de 'features'
X_train, X_test, y_train, y_test = train_test_split(exchange_features, exchange_target, test_size=0.2, random_state=24)
rfc_exchange_drift = RandomForestClassifier(random_state = 24).fit(X_train, y_train)

# Evaluar el nuevo modelo
exchange_y_test_pred = rfc_exchange_drift.predict(X_test)
exchange_accuracy = accuracy_score(y_test, exchange_y_test_pred)

print("Precisión inicial de modelo test: {}".format(rfc_test_accuracy))
print("Precisión del modelo drift por intercambio: {}".format(exchange_accuracy))

Precisión inicial de modelo test: 0.8949689869055824
Precisión del modelo drift por intercambio: 0.8970365265334252


# Se obtiene la importancia de las diferentes características del modelo
feature_importance = pd.DataFrame({'feature': list(features.columns), 'importance': list(rfc_exchange_drift.feature_importances_)})
feature_importance.sort_values('importance', ascending=False)


list_drift, first_drift = detect_drift_ADWIN(hotels_exchange_drift[feature2], int(n_rows/2))
print("Cambio detectado en el índice {}, valor de entrada: {}".format(first_drift[0], first_drift[1]))

Cambio detectado en el índice 18175, valor de entrada: 18


# Visualización del concept drift con el método 'Intercambio de features importantes'
display_drift(list_drift, 'ADWIN: '+feature2)


list_drift, first_drift = detect_drift_PH(hotels_exchange_drift[feature2], int(n_rows/2))
print("Cambio detectado en el índice {}, valor de entrada: {}".format(first_drift[0], first_drift[1]))

Cambio detectado en el índice 18167, valor de entrada: 69


# Visualización del concept drift con el método 'Intercambio de features importantes'
display_drift(list_drift, 'PageHinkley: '+feature2)


list_drift, first_drift = detect_drift_KSWIN(hotels_exchange_drift[feature2], int(n_rows/2))
print("Cambio detectado en el índice {}, valor de entrada: {}".format(first_drift[0], first_drift[1]))

Cambio detectado en el índice 18170, valor de entrada: 69


# Visualización del concept drift con el método 'Intercambio de features importantes'
display_drift(list_drift, 'KSWIN: '+feature2)


# Definir una función genérica de aprendizaje adaptativo
# El argumento "modelo" significa un algoritmo de aprendizaje adaptativo en línea
def adaptive_learning(model, X_train, y_train, X_test, y_test):
    metric = metrics.Accuracy()
    i = 0 # Contar el número de puntos de datos evaluados
    t = [] # Registrar el número de puntos de datos evaluados
    m = [] # Registrar la precisión en tiempo real
    yt = [] # Registrar todas las etiquetas verdaderas del conjunto de pruebas
    yp = [] # Registrar todas las etiquetas previstas del conjunto de pruebas

    # Aprender el conjunto de entrenamiento
    for xi1, yi1 in stream.iter_pandas(X_train, y_train):
        model.learn_one(xi1,yi1) 

    # Predecir el conjunto de pruebas
    for xi, yi in stream.iter_pandas(X_test, y_test):
        y_pred= model.predict_one(xi)  # Predecir la muestra de ensayo
        model.learn_one(xi,yi) # Aprende la muestra de la prueba
        metric = metric.update(yi, y_pred) # Actualizar la precisión en tiempo real
        t.append(i)
        m.append(metric.get()*100)
        yt.append(yi)
        yp.append(y_pred)
        i = i+1
    print("Accuracy: "+str(round(accuracy_score(yt,yp),4)*100)+"%")
    print("Precision: "+str(round(precision_score(yt,yp),4)*100)+"%")
    print("Recall: "+str(round(recall_score(yt,yp),4)*100)+"%")
    print("F1-score: "+str(round(f1_score(yt,yp),4)*100)+"%")
    return t, m


# Definir una función numérica que muestre los cambios de precisión en tiempo real
def acc_fig(t, m, name):
    plt.rcParams.update({'font.size': 15})
    plt.figure(1,figsize=(10,6)) 
    sns.set_style("darkgrid")
    plt.clf() 
    plt.plot(t,m,'-b',label='Avg Accuracy: %.2f%%'%(m[-1]))

    plt.legend(loc='best')
    plt.title(name, fontsize=15)
    plt.xlabel('Número de muestras')
    plt.ylabel('Precisión (%)')
    
    plt.draw()


X = hotels_time_drift.drop(['booking_status'],axis=1)
y = hotels_time_drift['booking_status']
X_train, X_test, y_train, y_test = train_test_split(X,y, train_size = 0.1, test_size = 0.9, random_state = 24)


# Usar el modelo Adaptive Random Forest (ARF) con el detector ADWIN
model1_1 = forest.ARFClassifier(n_models = 3, drift_detector = ADWIN()) # Definir el modelo
t, m1_1 = adaptive_learning(model1_1, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m1_1, "ARF-ADWIN model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 78.27%
Precision: 80.88%
Recall: 88.68%
F1-score: 84.6%


# Usar el modelo Adaptive Random Forest (ARF) con el detector PageHinkley
model1_2 = forest.ARFClassifier(n_models = 3, drift_detector = PageHinkley()) # Definir el modelo
t, m1_2 = adaptive_learning(model1_2, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m1_2, "ARF-PageHinkley model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 76.21%
Precision: 78.78%
Recall: 88.48%
F1-score: 83.35000000000001%


# Usar el modelo Adaptive Random Forest (ARF) con el detector KSWIN
model1_3 = forest.ARFClassifier(n_models = 3, drift_detector = KSWIN()) # Definir el modelo
t, m1_3 = adaptive_learning(model1_3, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m1_3, "ARF-KSWIN model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 78.88%
Precision: 80.95%
Recall: 89.74%
F1-score: 85.11999999999999%


# Usar el modelo Streaming Random Patches (SRP) con detector ADWIN
model2_1 = ensemble.SRPClassifier(n_models = 3, drift_detector = ADWIN()) # Definir el modelo
t, m2_1 = adaptive_learning(model2_1, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m2_1, "SRP-ADWIN model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 79.27%
Precision: 80.93%
Recall: 90.52%
F1-score: 85.46000000000001%


# Usar el modelo Streaming Random Patches (SRP) con detector PageHinkley
model2_2 = ensemble.SRPClassifier(n_models = 3, drift_detector = PageHinkley()) # Definir el modelo
t, m2_2 = adaptive_learning(model2_2, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m2_2, "SRP-PageHinkley model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 75.83%
Precision: 77.99000000000001%
Recall: 89.28%
F1-score: 83.25%


# Usar el modelo Streaming Random Patches (SRP) con detector KSWIN
model2_3 = ensemble.SRPClassifier(n_models = 3, drift_detector = KSWIN()) # Definir el modelo
t, m2_3 = adaptive_learning(model2_3, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m2_3, "SRP-KSWIN model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 79.44%
Precision: 81.15%
Recall: 90.46%
F1-score: 85.55%


# Dibuja una figura completa para comparar el rendimiento de todos los modelos
plt.rcParams.update({'font.size': 30})
plt.figure(1,figsize=(24,15)) 
sns.set_style("darkgrid")
plt.clf() 

# Visualiza el cambio de precisión de cada modelo
plt.plot(t,m1_1,'-g', label = 'ARP-ADWIN model, Avg Accuracy: %.2f%%'%(m1_1[-1]))
plt.plot(t,m1_2,'orange', label = 'ARP-PageHinkley model, Avg Accuracy: %.2f%%'%(m1_2[-1]))
plt.plot(t,m1_3,'-b', label = 'ARP-KSWIN model, Avg Accuracy: %.2f%%'%(m1_3[-1]))
plt.plot(t,m2_1,'magenta', label = 'SRP-ADWIN model, Avg Accuracy: %.2f%%'%(m2_1[-1]))
plt.plot(t,m2_2,'-r', label = 'SRP-PageHinkley model, Avg Accuracy: %.2f%%'%(m2_2[-1]))
plt.plot(t,m2_3,'brown', label= 'SRP-KSWIN model, Avg Accuracy: %.2f%%'%(m2_3[-1]))
        
plt.legend(loc='lower right')
plt.ylim(68, 85)
plt.xlabel('Número de muestras')
plt.ylabel('Precisión (%)')

plt.draw()


X = hotels_exchange_drift.drop(['booking_status'], axis=1)
y = hotels_exchange_drift['booking_status']
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size = 0.1, test_size = 0.9, random_state = 24)


# Usar el modelo Adaptive Random Forest (ARF) con el detector ADWIN
model3_1 = forest.ARFClassifier(n_models = 3, drift_detector = ADWIN()) # Definir el modelo
t, m3_1 = adaptive_learning(model3_1, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m3_1, "ARF-ADWIN model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 80.32000000000001%
Precision: 82.78%
Recall: 89.33%
F1-score: 85.92999999999999%


# Usar el modelo Adaptive Random Forest (ARF) con el detector PageHinkley
model3_2 = forest.ARFClassifier(n_models = 3, drift_detector = PageHinkley()) # Definir el modelo
t, m3_2 = adaptive_learning(model3_2, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m3_2, "ARF-PageHinkley model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 77.13%
Precision: 80.11%
Recall: 87.81%
F1-score: 83.78999999999999%


# Usar el modelo Adaptive Random Forest (ARF) con el detector KSWIN
model3_3 = forest.ARFClassifier(n_models = 3, drift_detector = KSWIN()) # Definir el modelo
t, m3_3 = adaptive_learning(model3_3, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m3_3, "ARF-KSWIN model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 82.46%
Precision: 84.33%
Recall: 90.8%
F1-score: 87.45%


# Usar el modelo Streaming Random Patches (SRP) con detector KSWIN
model4_1 = ensemble.SRPClassifier(n_models = 3, drift_detector = ADWIN()) # Definir el modelo
t, m4_1 = adaptive_learning(model4_1, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m4_1, "SRP-ADWIN model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 78.46%
Precision: 80.07%
Recall: 90.53%
F1-score: 84.98%


# Usar el modelo Streaming Random Patches (SRP) con detector KSWIN
model4_2 = ensemble.SRPClassifier(n_models = 3, drift_detector = PageHinkley()) # Definir el modelo
t, m4_2 = adaptive_learning(model4_2, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m4_2, "SRP-PageHinkley model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 75.8%
Precision: 78.03%
Recall: 89.13%
F1-score: 83.21%


# Usar el modelo Streaming Random Patches (SRP) con detector KSWIN
model4_3 = ensemble.SRPClassifier(n_models = 3, drift_detector = KSWIN()) # Definir el modelo
t, m4_3 = adaptive_learning(model4_3, X_train, y_train, X_test, y_test) # Aprender el modelo en el dataset
acc_fig(t, m4_3, "SRP-KSWIN model") # Dibuja la figura de cómo cambia la precisión en tiempo real con el número de muestras

Accuracy: 80.76%
Precision: 82.22%
Recall: 91.11%
F1-score: 86.44%


# Dibuja una figura completa para comparar el rendimiento de todos los modelos
plt.rcParams.update({'font.size': 30})
plt.figure(1,figsize=(24,15)) 
sns.set_style("darkgrid")
plt.clf() 

# Visualiza el cambio de precisión de cada modelo
plt.plot(t,m3_1,'-g', label = 'ARP-ADWIN model, Avg Accuracy: %.2f%%'%(m3_1[-1]))
plt.plot(t,m3_2,'orange', label = 'ARP-PageHinkley model, Avg Accuracy: %.2f%%'%(m3_2[-1]))
plt.plot(t,m3_3,'-b', label = 'ARP-KSWIN model, Avg Accuracy: %.2f%%'%(m3_3[-1]))
plt.plot(t,m4_1,'magenta',label = 'SRP-ADWIN model, Avg Accuracy: %.2f%%'%(m4_1[-1]))
plt.plot(t, m4_2,'-r', label = 'SRP-PageHinkley model, Avg Accuracy: %.2f%%'%(m4_2[-1]))
plt.plot(t,m4_3,'brown', label= 'SRP-KSWIN model, Avg Accuracy: %.2f%%'%(m4_3[-1]))
        
plt.legend(loc='lower right')
plt.ylim(68, 85)
plt.xlabel('Número de muestras')
plt.ylabel('Precisión (%)')

plt.draw()

	count	mean	std	min	25%	50%	75%	max
no_of_adults	36275.0	1.844962	0.518715	0.0	2.0	2.00	2.0	4.0
no_of_children	36275.0	0.105279	0.402648	0.0	0.0	0.00	0.0	10.0
no_of_weekend_nights	36275.0	0.810724	0.870644	0.0	0.0	1.00	2.0	7.0
no_of_week_nights	36275.0	2.204300	1.410905	0.0	1.0	2.00	3.0	17.0
required_car_parking_space	36275.0	0.030986	0.173281	0.0	0.0	0.00	0.0	1.0
lead_time	36275.0	85.232557	85.930817	0.0	17.0	57.00	126.0	443.0
arrival_year	36275.0	2017.820427	0.383836	2017.0	2018.0	2018.00	2018.0	2018.0
arrival_month	36275.0	7.423653	3.069894	1.0	5.0	8.00	10.0	12.0
arrival_date	36275.0	15.596995	8.740447	1.0	8.0	16.00	23.0	31.0
repeated_guest	36275.0	0.025637	0.158053	0.0	0.0	0.00	0.0	1.0
no_of_previous_cancellations	36275.0	0.023349	0.368331	0.0	0.0	0.00	0.0	13.0
no_of_previous_bookings_not_canceled	36275.0	0.153411	1.754171	0.0	0.0	0.00	0.0	58.0
avg_price_per_room	36275.0	103.423539	35.089424	0.0	80.3	99.45	120.0	540.0
no_of_special_requests	36275.0	0.619655	0.786236	0.0	0.0	0.00	1.0	5.0

	lead_time	market_segment_type	avg_price_per_room	no_of_guests	no_of_nights	date	booking_status
3871	257	1	101.5	2	2	20170701	0
26642	257	0	101.5	2	2	20170701	0
16946	257	0	101.5	2	2	20170701	0
3898	257	1	101.5	2	2	20170701	0
5884	257	0	80.0	1	2	20170701	1

	Booking_ID	no_of_adults	no_of_weekend_nights	no_of_week_nights	type_of_meal_plan	room_type_reserved	lead_time	arrival_year	arrival_month	arrival_date	market_segment_type	avg_price_per_room	no_of_special_requests	booking_status
0	INN00001	2	1	2	Meal Plan 1	Room_Type 1	224	2017	10	2	Offline	65.00	0	Not_Canceled
1	INN00002	2	2	3	Not Selected	Room_Type 1	5	2018	11	6	Online	106.68	1	Not_Canceled
2	INN00003	1	2	1	Meal Plan 1	Room_Type 1	1	2018	2	28	Online	60.00	0	Canceled
3	INN00004	2	0	2	Meal Plan 1	Room_Type 1	211	2018	5	20	Online	100.00	0	Canceled
4	INN00005	2	1	1	Not Selected	Room_Type 1	48	2018	4	11	Online	94.50	0	Canceled

	count	unique	top	freq
Booking_ID	36275	36275	INN00001	1
type_of_meal_plan	36275	4	Meal Plan 1	27835
room_type_reserved	36275	7	Room_Type 1	28130
market_segment_type	36275	5	Online	23214
booking_status	36275	2	Not_Canceled	24390

	type_of_meal_plan	room_type_reserved	lead_time	market_segment_type	avg_price_per_room	no_of_special_requests	no_of_guests	no_of_nights	date	booking_status
0	1	1	224	0	65.00	0	2	3	20171002	1
1	0	1	5	1	106.68	1	2	5	20181106	1
2	1	1	1	1	60.00	0	1	3	20180228	0
3	1	1	211	1	100.00	0	2	2	20180520	0
4	0	1	48	1	94.50	0	2	2	20180411	0

	feature	importance
1	lead_time	0.347151
8	date	0.200272
4	avg_price_per_room	0.192121
5	no_of_special_requests	0.095028
7	no_of_nights	0.063422
2	market_segment_type	0.061141
6	no_of_guests	0.031970
0	required_car_parking_space	0.006433
3	repeated_guest	0.002462

	feature	importance
5	no_of_special_requests	0.263240
1	lead_time	0.197692
8	date	0.192016
4	avg_price_per_room	0.188993
7	no_of_nights	0.065316
2	market_segment_type	0.052804
6	no_of_guests	0.031300
0	required_car_parking_space	0.006461
3	repeated_guest	0.002179

ML en cancelaciones de reservas online de hoteles¶

Índice¶

Carga de librerías¶

1. Carga del conjunto de datos¶

1.1. Descripción de las variables¶

1.2. Descripción estadística de las variables númericas¶

1.3. Valores nulos¶

1.4. Análisis de la variable 'booking_status'¶

2. Análisis de los datos¶

2.1. Análisis exploratorio de datos¶

2.1.1. Análisis de las variables categóricas¶

2.1.2. Análisis de variables numéricas¶

2.1.3. Análisis de las variables en relación a 'booking_status'¶

2.1.4. Análisis entre variables¶

2.1.5. Conclusiones sobre las variables¶

2.2. Preprocesamiento de los datos¶

2.2.1. Creación de nuevas variables¶

2.2.2. Ajuste y transformación de variables¶

2.2.3. Correlación de las variables¶

2.2.4. Reducción de dimensionalidad¶

2.3. Conclusiones del análisis de datos¶

3. Entrenamiento de un modelo¶

3.1. Conclusiones de los modelos desarrollados¶

3.2. Importancia de las variables del modelo¶

3.3. Predicción de nuevos casos¶

4. Concept drift¶

4.1. Diferentes tipos de detectores¶

4.2. Drift basado en la distribución del tiempo¶

4.2.1. Visualización del concept drift: Método ADWIN¶

4.2.2. Visualización del concept drift: Método PageHinkley¶

4.2.3. Visualización del concept drift: Método KSWIN¶

4.3. Cambio en las características¶

4.3.1. Eliminación de variables importantes¶

4.3.2. Intercambio de dos variables importantes¶

4.3.2.1. Visualización del concept drift: Método ADWIN¶

4.3.2.2. Visualización del concept drift: Método PageHinkley¶

4.3.2.3. Visualización del concept drift: Método KSWIN¶

5. Estrategias de adaptación¶

5.1. Adaptación para el drift basado en la distribución del tiempo¶

5.1.1. Adaptive Random Forest¶

5.1.2. Streaming Random Patches¶

5.1.3. Comparación de modelos¶

5.2. Adaptación para el drift del cambio en las características¶

5.2.1. Adaptive Random Forest¶

5.2.2. Streaming Random Patches¶

5.2.3. Comparación de modelos¶

6. Conclusiones generales¶